const { userApi, classApi } = require('../../utils/api');

// 搜索防抖定时器
let searchTimer = null;

Page({
  data: {
    searchKeyword: '',
    currentCategory: 'all',
    contacts: [],
    filteredContacts: [],
    groupedContacts: [],
    loading: false,
    refreshing: false,
    totalContacts: 0,
    teacherCount: 0,
    studentCount: 0,
    parentCount: 0,
    showIndex: false,
    indexList: [],
    statsExpanded: false,  // 统计信息展开状态
    contactsExpanded: false,  // 联系人列表展开状态
    
    // 班级相关数据
    classes: [],
    classStats: {
      totalClasses: 0,
      myClasses: 0,
      headteacherClasses: 0
    },
    classesExpanded: false,  // 班级列表展开状态
    loadingClasses: false
  },

  onLoad: function (options) {
    console.log('通讯录页面加载');
    this.loadContacts();
    this.loadClasses();
  },

  onShow: function () {
    console.log('通讯录页面显示');
  },

  // 下拉刷新
  onPullDownRefresh() {
    this.setData({ refreshing: true });
    Promise.all([
      this.loadContacts(),
      this.loadClasses()
    ]).then(() => {
      wx.stopPullDownRefresh();
      this.setData({ refreshing: false });
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1500
      });
    });
  },

  // 加载联系人列表
  async loadContacts() {
    this.setData({ loading: true });
    
    try {
      console.log('开始请求联系人列表...');
      console.log('请求URL: http://localhost:1003/tea/user/list');
      
      const response = await userApi.getAllUsers();
      console.log('API响应成功:', response);
      
      // 检查响应数据格式
      if (!response) {
        throw new Error('API返回数据为空');
      }
      
      // 处理新的Result格式响应
      let contacts = [];
      if (response.code === 200 && response.data) {
        contacts = response.data;
      } else if (Array.isArray(response)) {
        // 兼容旧格式
        contacts = response;
      } else {
        throw new Error(response.message || 'API返回数据格式错误');
      }
      
      console.log('解析后的联系人数据:', contacts);
      console.log('联系人数据长度:', contacts.length);
      
      // 处理联系人数据 - 根据实际API数据格式处理
      const processedContacts = contacts.map(contact => ({
        ...contact,
        // 统一字段名，将nickname映射为name
        name: contact.nickname || contact.name || '未知用户',
        // 角色处理
        role: this.getRoleText(contact.identity),
        avatar: this.getAvatarByRole(contact.identity),
        // 确保必要字段存在
        phone: contact.phone || '',
        email: contact.email || '',
        userId: contact.id || contact.userId || contact.userid,
        // 班级信息
        classId: contact.classId || null,
        // 状态信息
        status: contact.status || 1,
        // 时间信息
        createTime: contact.createTime || '',
        updateTime: contact.updateTime || ''
      }));
      
      console.log('处理后的联系人数据:', processedContacts);
      
      // 统计各类型联系人数量
      const stats = this.calculateContactStats(processedContacts);
      console.log('计算出的统计数据:', stats);
      
      this.setData({
        contacts: processedContacts,
        filteredContacts: processedContacts,
        ...stats,
        loading: false
      });
      
      console.log('设置到data中的统计数据:', {
        totalContacts: stats.totalContacts,
        teacherCount: stats.teacherCount,
        studentCount: stats.studentCount,
        parentCount: stats.parentCount
      });
      
      this.filterContacts();
      
      wx.showToast({
        title: `加载成功，共${processedContacts.length}个联系人`,
        icon: 'success',
        duration: 1500
      });
      
    } catch (error) {
      console.error('获取联系人列表失败:', error);
      console.error('错误类型:', typeof error);
      console.error('错误消息:', error.message);
      console.error('错误堆栈:', error.stack);
      
      this.setData({ loading: false });
      
      // 显示详细错误信息
      let errorMessage = '加载失败';
      if (error.message && error.message.includes('500')) {
        errorMessage = '服务器内部错误(500)，请检查后端服务';
      } else if (error.message && error.message.includes('404')) {
        errorMessage = '接口不存在(404)，请检查API地址';
      } else if (error.message && error.message.includes('网络')) {
        errorMessage = '网络连接失败，请检查网络';
      } else {
        errorMessage = `请求失败: ${error.message}`;
      }
      
      wx.showModal({
        title: '加载失败',
        content: errorMessage,
        showCancel: true,
        cancelText: '重试',
        confirmText: '确定',
        success: (res) => {
          if (res.cancel) {
            // 用户点击重试
            this.loadContacts();
          }
        }
      });
    }
  },

  // 获取角色文本
  getRoleText(identity) {
    const roleMap = {
      'teacher': '老师',
      'student': '学生',
      'parent': '家长',
      'admin': '管理员'
    };
    return roleMap[identity] || '未知';
  },

  // 根据角色获取头像
  getAvatarByRole(identity) {
    const avatarMap = {
      'teacher': '👨‍🏫',
      'student': '👨‍🎓',
      'parent': '👨‍👩‍👧‍👦',
      'admin': '👨‍💼'
    };
    return avatarMap[identity] || '👤';
  },

  // 计算联系人统计
  calculateContactStats(contacts) {
    const stats = {
      totalContacts: contacts.length,
      teacherCount: 0,
      studentCount: 0,
      parentCount: 0
    };
    
    contacts.forEach(contact => {
      console.log('处理联系人:', contact.nickname, '身份:', contact.identity);
      const identity = contact.identity ? contact.identity.toLowerCase() : '';
      switch (identity) {
        case 'teacher':
        case '老师':
          stats.teacherCount++;
          break;
        case 'student':
        case '学生':
          stats.studentCount++;
          break;
        case 'parent':
        case '家长':
          stats.parentCount++;
          break;
      }
    });
    
    console.log('统计结果:', stats);
    
    return stats;
  },

  // 搜索输入（带防抖）
  onSearchInput(e) {
    const keyword = e.detail.value;
    this.setData({
      searchKeyword: keyword
    });
    
    // 清除之前的定时器
    if (searchTimer) {
      clearTimeout(searchTimer);
    }
    
    // 设置新的定时器（300ms防抖）
    searchTimer = setTimeout(() => {
      this.filterContacts();
    }, 300);
  },

  // 清除搜索
  clearSearch() {
    this.setData({
      searchKeyword: ''
    });
    this.filterContacts();
  },

  // 切换分类
  switchCategory(e) {
    const category = e.currentTarget.dataset.category;
    this.setData({
      currentCategory: category
    });
    this.filterContacts();
  },

  // 筛选联系人
  filterContacts() {
    const { contacts, searchKeyword, currentCategory } = this.data;
    let filtered = [...contacts];
    
    // 按分类筛选（修复：teacher 对应 teacher，而不是 teachers）
    if (currentCategory !== 'all') {
      filtered = filtered.filter(contact => contact.identity === currentCategory);
    }
    
    // 按关键词搜索
    if (searchKeyword) {
      const keyword = searchKeyword.toLowerCase();
      filtered = filtered.filter(contact => 
        (contact.name && contact.name.toLowerCase().includes(keyword)) ||
        (contact.phone && contact.phone.includes(keyword)) ||
        (contact.role && contact.role.toLowerCase().includes(keyword))
      );
    }
    
    // 按姓名首字母分组并排序
    const grouped = this.groupContactsByLetter(filtered);
    
    this.setData({
      filteredContacts: filtered,
      groupedContacts: grouped
    });
  },

  // 按首字母分组联系人
  groupContactsByLetter(contacts) {
    const groups = {};
    const indexList = [];
    
    contacts.forEach(contact => {
      // 获取姓名首字母（简单处理，实际项目可以使用 pinyin 库）
      const firstChar = this.getFirstLetter(contact.name);
      
      if (!groups[firstChar]) {
        groups[firstChar] = [];
        indexList.push(firstChar);
      }
      groups[firstChar].push(contact);
    });
    
    // 排序索引列表
    indexList.sort();
    
    // 转换为数组格式
    const result = indexList.map(letter => ({
      letter,
      contacts: groups[letter]
    }));
    
    this.setData({ indexList });
    
    return result;
  },

  // 获取首字母（简化版）
  getFirstLetter(name) {
    if (!name) return '#';
    const char = name.charAt(0).toUpperCase();
    // 简单判断是否为英文字母
    if (/[A-Z]/.test(char)) {
      return char;
    }
    // 中文简单处理，返回 '#'
    return '#';
  },

  // 点击联系人
  onContactTap(e) {
    const { contact } = e.currentTarget.dataset;
    console.log('点击联系人:', contact);
    
    wx.showActionSheet({
      itemList: ['查看详情', '拨打电话', '发送消息'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.viewContactDetail(contact);
            break;
          case 1:
            this.callContact(contact.phone);
            break;
          case 2:
            this.messageContact(contact.userid);
            break;
        }
      }
    });
  },

  // 查看联系人详情
  viewContactDetail(contact) {
    wx.showModal({
      title: contact.name,
      content: `角色：${contact.role}\n电话：${contact.phone}\n邮箱：${contact.email || '未设置'}`,
      showCancel: false
    });
  },

  // 拨打电话
  callContact(phone) {
    wx.makePhoneCall({
      phoneNumber: phone,
      success: () => {
        console.log('拨打电话成功');
      },
      fail: (err) => {
        console.error('拨打电话失败:', err);
        wx.showToast({
          title: '拨打电话失败',
          icon: 'none'
        });
      }
    });
  },

  // 发送消息
  messageContact(userId) {
    wx.showToast({
      title: '消息功能开发中',
      icon: 'none'
    });
  },

  // 添加联系人
  addContact() {
    wx.showToast({
      title: '添加联系人功能开发中',
      icon: 'none'
    });
  },

  // 导入花名册
  importRoster() {
    wx.showToast({
      title: '导入花名册功能开发中',
      icon: 'none'
    });
  },

  // 管理审核
  manageAudit() {
    wx.showToast({
      title: '进班审核功能开发中',
      icon: 'none'
    });
  },

  // 管理分组
  manageGroups() {
    wx.showToast({
      title: '学生分组功能开发中',
      icon: 'none'
    });
  },

  // 打开消息
  openMessages() {
    wx.showToast({
      title: '私信功能开发中',
      icon: 'none'
    });
  },

  // 邀请成员
  inviteMembers() {
    wx.showToast({
      title: '邀请功能开发中',
      icon: 'none'
    });
  },

  // 测试API连接
  testApiConnection() {
    wx.showLoading({ title: '测试API连接...' });
    
    console.log('开始测试API连接...');
    console.log('目标URL: http://localhost:1003/tea/user/list');
    
    userApi.getAllUsers()
      .then(response => {
        console.log('API测试成功:', response);
        wx.hideLoading();
        wx.showModal({
          title: 'API连接成功',
          content: `接口返回数据：${JSON.stringify(response).substring(0, 300)}...`,
          showCancel: false
        });
      })
      .catch(error => {
        console.error('API测试失败:', error);
        wx.hideLoading();
        wx.showModal({
          title: 'API连接失败',
          content: `错误信息：${error.message}\n\n请检查：\n1. 后端服务是否启动\n2. 端口1003是否可用\n3. 接口路径是否正确`,
          showCancel: true,
          cancelText: '重试',
          confirmText: '确定',
          success: (res) => {
            if (res.cancel) {
              this.testApiConnection();
            }
          }
        });
      });
  },

  // 跳转到班级列表
  goToClassList() {
    wx.navigateTo({
      url: '/pages/class/class-list/index'
    });
  },

  // 跳转到新建班级页面
  goToCreateClass() {
    wx.navigateTo({
      url: '/pages/class/create-class/index'
    });
  },

  // 切换统计信息展开/收缩状态
  toggleStatsDetail() {
    this.setData({
      statsExpanded: !this.data.statsExpanded
    });
    
    // 添加触觉反馈
    wx.vibrateShort({
      type: 'light'
    });
  },

  // 切换联系人列表展开/收缩状态
  toggleContactsDetail() {
    this.setData({
      contactsExpanded: !this.data.contactsExpanded
    });
    
    // 添加触觉反馈
    wx.vibrateShort({
      type: 'light'
    });
  },

  // ==================== 班级相关功能 ====================
  
  // 加载班级列表
  async loadClasses() {
    this.setData({ loadingClasses: true });
    
    try {
      console.log('开始加载班级列表...');
      
      // 获取所有班级信息
      const classesResponse = await classApi.getAllClasses();
      console.log('班级列表API响应:', classesResponse);
      
      // 处理新的Result格式响应
      let classesResult = [];
      if (classesResponse && classesResponse.code === 200 && classesResponse.data) {
        classesResult = classesResponse.data;
      } else if (Array.isArray(classesResponse)) {
        // 兼容旧格式
        classesResult = classesResponse;
      }
      
      if (classesResult && classesResult.length > 0) {
        // 处理班级数据
        const processedClasses = classesResult.map(classItem => ({
          ...classItem,
          // 格式化时间
          createTimeFormatted: this.formatTime(classItem.createTime),
          // 状态文本
          statusText: classItem.isHeadteacher === 1 ? '班主任' : '任课教师'
        }));
        
        // 计算班级统计
        const classStats = this.calculateClassStats(processedClasses);
        
        this.setData({
          classes: processedClasses,
          classStats: classStats,
          loadingClasses: false
        });
        
        console.log('班级列表加载成功:', processedClasses);
      } else {
        this.setData({
          classes: [],
          classStats: { totalClasses: 0, myClasses: 0, headteacherClasses: 0 },
          loadingClasses: false
        });
      }
      
    } catch (error) {
      console.error('加载班级列表失败:', error);
      this.setData({ loadingClasses: false });
      
      wx.showToast({
        title: '班级列表加载失败',
        icon: 'none'
      });
    }
  },

  // 计算班级统计信息
  calculateClassStats(classes) {
    const stats = {
      totalClasses: classes.length,
      myClasses: 0,
      headteacherClasses: 0
    };
    
    classes.forEach(classItem => {
      if (classItem.isHeadteacher === 1) {
        stats.headteacherClasses++;
      }
      // 这里可以根据当前用户ID判断是否是我的班级
      // stats.myClasses++;
    });
    
    return stats;
  },

  // 格式化时间
  formatTime(timeStr) {
    if (!timeStr) return '';
    try {
      const date = new Date(timeStr);
      return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
    } catch (e) {
      return timeStr;
    }
  },

  // 切换班级列表展开/收缩状态
  toggleClassesDetail() {
    this.setData({
      classesExpanded: !this.data.classesExpanded
    });
    
    // 添加触觉反馈
    wx.vibrateShort({
      type: 'light'
    });
  },

  // 点击班级项
  onClassTap(e) {
    const { classItem } = e.currentTarget.dataset;
    console.log('点击班级:', classItem);
    
    wx.showActionSheet({
      itemList: ['查看详情', '查看成员', '班级管理'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.viewClassDetail(classItem);
            break;
          case 1:
            this.viewClassMembers(classItem);
            break;
          case 2:
            this.manageClass(classItem);
            break;
        }
      }
    });
  },

  // 查看班级详情
  viewClassDetail(classItem) {
    wx.showModal({
      title: classItem.className,
      content: `年级：${classItem.grade}\n科目：${classItem.subject}\n邀请码：${classItem.classCode}\n创建时间：${classItem.createTimeFormatted}`,
      showCancel: false
    });
  },

  // 查看班级成员
  viewClassMembers(classItem) {
    wx.navigateTo({
      url: `/pages/class/class-members/index?classId=${classItem.classId}&className=${encodeURIComponent(classItem.className)}`
    });
  },

  // 班级管理
  manageClass(classItem) {
    wx.showActionSheet({
      itemList: ['编辑班级', '删除班级', '班级设置'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            this.editClass(classItem);
            break;
          case 1:
            this.deleteClass(classItem);
            break;
          case 2:
            this.classSettings(classItem);
            break;
        }
      }
    });
  },

  // 编辑班级
  editClass(classItem) {
    wx.navigateTo({
      url: `/pages/class/create-class/index?mode=edit&classId=${classItem.classId}`
    });
  },

  // 删除班级
  deleteClass(classItem) {
    wx.showModal({
      title: '确认删除',
      content: `确定要删除班级"${classItem.className}"吗？此操作不可恢复。`,
      confirmText: '删除',
      confirmColor: '#ff4444',
      success: (res) => {
        if (res.confirm) {
          this.performDeleteClass(classItem.classId);
        }
      }
    });
  },

  // 执行删除班级
  async performDeleteClass(classId) {
    try {
      wx.showLoading({ title: '删除中...' });
      
      // 这里调用删除班级的API
      // await classApi.deleteClass(classId);
      
      wx.hideLoading();
      wx.showToast({
        title: '删除成功',
        icon: 'success'
      });
      
      // 重新加载班级列表
      this.loadClasses();
      
    } catch (error) {
      wx.hideLoading();
      console.error('删除班级失败:', error);
      wx.showToast({
        title: '删除失败',
        icon: 'none'
      });
    }
  },

  // 班级设置
  classSettings(classItem) {
    wx.showToast({
      title: '班级设置功能开发中',
      icon: 'none'
    });
  },

  // 搜索班级
  onClassSearchInput(e) {
    const keyword = e.detail.value;
    this.setData({
      classSearchKeyword: keyword
    });
    
    // 这里可以实现班级搜索逻辑
    this.filterClasses();
  },

  // 筛选班级
  filterClasses() {
    const { classes, classSearchKeyword } = this.data;
    let filtered = [...classes];
    
    if (classSearchKeyword) {
      const keyword = classSearchKeyword.toLowerCase();
      filtered = filtered.filter(classItem => 
        classItem.className.toLowerCase().includes(keyword) ||
        classItem.grade.toLowerCase().includes(keyword) ||
        classItem.subject.toLowerCase().includes(keyword)
      );
    }
    
    this.setData({
      filteredClasses: filtered
    });
  },

  // 清除班级搜索
  clearClassSearch() {
    this.setData({
      classSearchKeyword: ''
    });
    this.filterClasses();
  }
})
